package com.xjd.edu.toolkit.helper;

import java.util.Collection;
import java.util.Objects;

/**
 * 操作符（语法糖）
 *
 * @author wangyu
 * @since 2022/4/19
 */
public class Operator {

    /**
     * IN 操作符 -> $base 是否存在于 $elements 中
     *
     * @param base     比较基准值，非空，空则返回FALSE
     * @param elements 比较列表值，非空，空则返回FALSE
     * @param <T>
     * @return
     */
    public static <T> boolean IN(T base, Collection<T> elements) {
        if (base == null || elements == null || elements.isEmpty()) {
            return false;
        }
        return elements.contains(base);
    }

    /**
     * IN 操作符 -> $base 是否存在于 $elements 中
     *
     * @param base     比较基准值，非空，空则返回FALSE
     * @param elements 比较数组值，非空，空则返回FALSE
     * @param <T>
     * @return
     */
    public static <T> boolean IN(T base, T[] elements) {
        if (base == null || elements == null || elements.length == 0) {
            return false;
        }
        for (T e : elements) {
            if (e != null && Objects.equals(base, e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * IN 操作符 -> $base 是否存在于区间中
     *
     * @param base          比较基准值，非空，空则返回FALSE
     * @param fromInclusive 区间起始值（包含），空则表示无下限，与结束值必有一个非空，否则返回FALSE
     * @param toInclusive   区间结束值（包含），空则表示无上限，与起始值必有一个非空，否则返回FALSE
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> boolean IN(T base, T fromInclusive, T toInclusive) {
        if (base == null || (fromInclusive == null && toInclusive == null)) {
            return false;
        }
        if (fromInclusive != null && base.compareTo(fromInclusive) < 0) {
            return false;
        }
        return toInclusive == null || base.compareTo(toInclusive) <= 0;
    }

}
